﻿// 2020/2/25
using UnityEngine;
using UnityEditor;

public class UTSGUI : ShaderGUI
{

    public enum _UTS_Technique
    {
        DoubleSideWithFeather, ShadingGradeMap, OutlineObject
    }
    public enum _OutlineMode
    {
        NormalDirection, PositionScaling
    }

    public enum _CullingMode
    {
        CullingOff, FrontCulling, BackCulling
    }

    public enum _EmissiveMode
    {
        SimpleEmissive, EmissiveAnimation
    }

    //enum _OutlineMode の状態を保持するための変数.
    public _OutlineMode outlineMode;
    public _CullingMode cullingMode;
    public _EmissiveMode emissiveMode;

    //ボタンサイズ.
    public GUILayoutOption[] shortButtonStyle = new GUILayoutOption[] { GUILayout.Width(130) };
    public GUILayoutOption[] middleButtonStyle = new GUILayoutOption[] { GUILayout.Width(130) };

    //各種設定保持用.
    //UTS2のバージョン.
    static float _UTS2VersionNumber = 2.075f;
    //
    static int _StencilNo_Setting;
    static bool _OriginalInspector = false;
    static bool _SimpleUI = false;
    //メッセージ表示用.
    bool _Use_VrcRecommend = false;
    bool _RemovedUnusedKeywordsMessage = false;

    //Foldoutの初期値.
    static bool _BasicShaderSettings_Foldout = false;
    static bool _BasicThreeColors_Foldout = true;
    static bool _NormalMap_Foldout = false;
    static bool _ShadowControlMaps_Foldout = false;
    static bool _StepAndFeather_Foldout = true;
    static bool _AdditionalLookdevs_Foldout = false;
    static bool _HighColor_Foldout = true;
    static bool _RimLight_Foldout = true;
    static bool _MatCap_Foldout = true;
    static bool _AngelRing_Foldout = true;
    static bool _Emissive_Foldout = true;
    static bool _Outline_Foldout = true;
    static bool _AdvancedOutline_Foldout = false;
    static bool _Tessellation_Foldout = false;
    static bool _LightColorContribution_Foldout = false;
    static bool _AdditionalLightingSettings_Foldout = false;

    // -----------------------------------------------------
    //m_MaterialEditorのメソッドをUIとして使うもののみを指定する.
    // UTS2 materal properties -------------------------
    MaterialProperty clippingMask = null;
    MaterialProperty clipping_Level = null;
    MaterialProperty tweak_transparency = null;
    MaterialProperty mainTex = null;
    MaterialProperty baseColor = null;
    MaterialProperty firstShadeMap = null;
    MaterialProperty firstShadeColor = null;
    MaterialProperty secondShadeMap = null;
    MaterialProperty secondShadeColor = null;
    MaterialProperty normalMap = null;
    MaterialProperty bumpScale = null;
    MaterialProperty set_1st_ShadePosition = null;
    MaterialProperty set_2nd_ShadePosition = null;
    MaterialProperty shadingGradeMap = null;
    MaterialProperty tweak_ShadingGradeMapLevel = null;
    MaterialProperty blurLevelSGM = null;
    MaterialProperty tweak_SystemShadowsLevel = null;
    MaterialProperty baseColor_Step = null;
    MaterialProperty baseShade_Feather = null;
    MaterialProperty shadeColor_Step = null;
    MaterialProperty first2nd_Shades_Feather = null;
    MaterialProperty first_ShadeColor_Step = null;
    MaterialProperty first_ShadeColor_Feather = null;
    MaterialProperty second_ShadeColor_Step = null;
    MaterialProperty second_ShadeColor_Feather = null;
    MaterialProperty stepOffset = null;
    MaterialProperty highColor_Tex = null;
    MaterialProperty highColor = null;
    MaterialProperty highColor_Power = null;
    MaterialProperty tweakHighColorOnShadow = null;
    MaterialProperty set_HighColorMask = null;
    MaterialProperty tweak_HighColorMaskLevel = null;
    MaterialProperty rimLightColor = null;
    MaterialProperty rimLight_Power = null;
    MaterialProperty rimLight_InsideMask = null;
    MaterialProperty tweak_LightDirection_MaskLevel = null;
    MaterialProperty ap_RimLightColor = null;
    MaterialProperty ap_RimLight_Power = null;
    MaterialProperty set_RimLightMask = null;
    MaterialProperty tweak_RimLightMaskLevel = null;
    MaterialProperty matCap_Sampler = null;
    MaterialProperty matCapColor = null;
    MaterialProperty blurLevelMatcap = null;
    MaterialProperty tweak_MatCapUV = null;
    MaterialProperty rotate_MatCapUV = null;
    MaterialProperty normalMapForMatCap = null;
    MaterialProperty bumpScaleMatcap = null;
    MaterialProperty rotate_NormalMapForMatCapUV = null;
    MaterialProperty tweakMatCapOnShadow = null;
    MaterialProperty set_MatcapMask = null;
    MaterialProperty tweak_MatcapMaskLevel = null;
    MaterialProperty angelRing_Sampler = null;
    MaterialProperty angelRing_Color = null;
    MaterialProperty ar_OffsetU = null;
    MaterialProperty ar_OffsetV = null;
    MaterialProperty emissive_Tex = null;
    MaterialProperty emissive_Color = null;
    MaterialProperty base_Speed = null;
    MaterialProperty scroll_EmissiveU = null;
    MaterialProperty scroll_EmissiveV = null;
    MaterialProperty rotate_EmissiveUV = null;
    MaterialProperty colorShift = null;
    MaterialProperty colorShift_Speed = null;
    MaterialProperty viewShift = null;
    MaterialProperty outline_Width = null;
    MaterialProperty outline_Color = null;
    MaterialProperty outline_Sampler = null;
    MaterialProperty offset_Z = null;
    MaterialProperty farthest_Distance = null;
    MaterialProperty nearest_Distance = null;
    MaterialProperty outlineTex = null;
    MaterialProperty bakedNormal = null;
    MaterialProperty tessEdgeLength = null;
    MaterialProperty tessPhongStrength = null;
    MaterialProperty tessExtrusionAmount = null;
    MaterialProperty gi_Intensity = null;
    MaterialProperty unlit_Intensity = null;
    MaterialProperty offset_X_Axis_BLD = null;
    MaterialProperty offset_Y_Axis_BLD = null;
    //------------------------------------------------------

    MaterialEditor m_MaterialEditor;

    // -----------------------------------------------------

    //m_MaterialEditorのメソッドをUIとして使うもののみを指定する.
    public void FindProperties(MaterialProperty[] props)
    {
        //シェーダーによって無い可能性があるプロパティはfalseを追加.
        clippingMask = FindProperty("_ClippingMask", props, false);
        clipping_Level = FindProperty("_Clipping_Level", props, false);
        tweak_transparency = FindProperty("_Tweak_transparency", props, false);
        mainTex = FindProperty("_MainTex", props);
        baseColor = FindProperty("_BaseColor", props);
        firstShadeMap = FindProperty("_1st_ShadeMap", props);
        firstShadeColor = FindProperty("_1st_ShadeColor", props);
        secondShadeMap = FindProperty("_2nd_ShadeMap", props);
        secondShadeColor = FindProperty("_2nd_ShadeColor", props);
        normalMap = FindProperty("_NormalMap", props);
        bumpScale = FindProperty("_BumpScale", props);
        set_1st_ShadePosition = FindProperty("_Set_1st_ShadePosition", props, false);
        set_2nd_ShadePosition = FindProperty("_Set_2nd_ShadePosition", props, false);
        shadingGradeMap = FindProperty("_ShadingGradeMap", props, false);
        tweak_ShadingGradeMapLevel = FindProperty("_Tweak_ShadingGradeMapLevel", props, false);
        blurLevelSGM = FindProperty("_BlurLevelSGM", props, false);
        tweak_SystemShadowsLevel = FindProperty("_Tweak_SystemShadowsLevel", props);
        baseColor_Step = FindProperty("_BaseColor_Step", props);
        baseShade_Feather = FindProperty("_BaseShade_Feather", props);
        shadeColor_Step = FindProperty("_ShadeColor_Step", props);
        first2nd_Shades_Feather = FindProperty("_1st2nd_Shades_Feather", props);
        first_ShadeColor_Step = FindProperty("_1st_ShadeColor_Step", props);
        first_ShadeColor_Feather = FindProperty("_1st_ShadeColor_Feather", props);
        second_ShadeColor_Step = FindProperty("_2nd_ShadeColor_Step", props);
        second_ShadeColor_Feather = FindProperty("_2nd_ShadeColor_Feather", props);
        stepOffset = FindProperty("_StepOffset", props, false);
        highColor_Tex = FindProperty("_HighColor_Tex", props);
        highColor = FindProperty("_HighColor", props);
        highColor_Power = FindProperty("_HighColor_Power", props);
        tweakHighColorOnShadow = FindProperty("_TweakHighColorOnShadow", props);
        set_HighColorMask = FindProperty("_Set_HighColorMask", props);
        tweak_HighColorMaskLevel = FindProperty("_Tweak_HighColorMaskLevel", props);
        rimLightColor = FindProperty("_RimLightColor", props);
        rimLight_Power = FindProperty("_RimLight_Power", props);
        rimLight_InsideMask = FindProperty("_RimLight_InsideMask", props);
        tweak_LightDirection_MaskLevel = FindProperty("_Tweak_LightDirection_MaskLevel", props);
        ap_RimLightColor = FindProperty("_Ap_RimLightColor", props);
        ap_RimLight_Power = FindProperty("_Ap_RimLight_Power", props);
        set_RimLightMask = FindProperty("_Set_RimLightMask", props);
        tweak_RimLightMaskLevel = FindProperty("_Tweak_RimLightMaskLevel", props);
        matCap_Sampler = FindProperty("_MatCap_Sampler", props);
        matCapColor = FindProperty("_MatCapColor", props);
        blurLevelMatcap = FindProperty("_BlurLevelMatcap", props);
        tweak_MatCapUV = FindProperty("_Tweak_MatCapUV", props);
        rotate_MatCapUV = FindProperty("_Rotate_MatCapUV", props);
        normalMapForMatCap = FindProperty("_NormalMapForMatCap", props);
        bumpScaleMatcap = FindProperty("_BumpScaleMatcap", props);
        rotate_NormalMapForMatCapUV = FindProperty("_Rotate_NormalMapForMatCapUV", props);
        tweakMatCapOnShadow = FindProperty("_TweakMatCapOnShadow", props);
        set_MatcapMask = FindProperty("_Set_MatcapMask", props);
        tweak_MatcapMaskLevel = FindProperty("_Tweak_MatcapMaskLevel", props);
        angelRing_Sampler = FindProperty("_AngelRing_Sampler", props, false);
        angelRing_Color = FindProperty("_AngelRing_Color", props, false);
        ar_OffsetU = FindProperty("_AR_OffsetU", props, false);
        ar_OffsetV = FindProperty("_AR_OffsetV", props, false);
        emissive_Tex = FindProperty("_Emissive_Tex", props);
        emissive_Color = FindProperty("_Emissive_Color", props);
        base_Speed = FindProperty("_Base_Speed", props);
        scroll_EmissiveU = FindProperty("_Scroll_EmissiveU", props);
        scroll_EmissiveV = FindProperty("_Scroll_EmissiveV", props);
        rotate_EmissiveUV = FindProperty("_Rotate_EmissiveUV", props);
        colorShift = FindProperty("_ColorShift", props);
        colorShift_Speed = FindProperty("_ColorShift_Speed", props);
        viewShift = FindProperty("_ViewShift", props);
        outline_Width = FindProperty("_Outline_Width", props, false);
        outline_Color = FindProperty("_Outline_Color", props, false);
        outline_Sampler = FindProperty("_Outline_Sampler", props, false);
        offset_Z = FindProperty("_Offset_Z", props, false);
        farthest_Distance = FindProperty("_Farthest_Distance", props, false);
        nearest_Distance = FindProperty("_Nearest_Distance", props, false);
        outlineTex = FindProperty("_OutlineTex", props, false);
        bakedNormal = FindProperty("_BakedNormal", props, false);
        tessEdgeLength = FindProperty("_TessEdgeLength", props, false);
        tessPhongStrength = FindProperty("_TessPhongStrength", props, false);
        tessExtrusionAmount = FindProperty("_TessExtrusionAmount", props, false);
        gi_Intensity = FindProperty("_GI_Intensity", props);
        unlit_Intensity = FindProperty("_Unlit_Intensity", props);
        offset_X_Axis_BLD = FindProperty("_Offset_X_Axis_BLD", props);
        offset_Y_Axis_BLD = FindProperty("_Offset_Y_Axis_BLD", props);
    }
    // --------------------------------

    // --------------------------------
    static void Line()
    {
        GUILayout.Box("", GUILayout.ExpandWidth(true), GUILayout.Height(1));
    }

    static bool Foldout(bool display, string title)
    {
        var style = new GUIStyle("ShurikenModuleTitle");
        style.font = new GUIStyle(EditorStyles.boldLabel).font;
        style.border = new RectOffset(15, 7, 4, 4);
        style.fixedHeight = 22;
        style.contentOffset = new Vector2(20f, -2f);

        var rect = GUILayoutUtility.GetRect(16f, 22f, style);
        GUI.Box(rect, title, style);

        var e = Event.current;

        var toggleRect = new Rect(rect.x + 4f, rect.y + 2f, 13f, 13f);
        if (e.type == EventType.Repaint)
        {
            EditorStyles.foldout.Draw(toggleRect, false, false, display, false);
        }

        if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
        {
            display = !display;
            e.Use();
        }

        return display;
    }

    static bool FoldoutSubMenu(bool display, string title)
    {
        var style = new GUIStyle("ShurikenModuleTitle");
        style.font = new GUIStyle(EditorStyles.boldLabel).font;
        style.border = new RectOffset(15, 7, 4, 4);
        style.padding = new RectOffset(5, 7, 4, 4);
        style.fixedHeight = 22;
        style.contentOffset = new Vector2(32f, -2f);

        var rect = GUILayoutUtility.GetRect(16f, 22f, style);
        GUI.Box(rect, title, style);

        var e = Event.current;

        var toggleRect = new Rect(rect.x + 16f, rect.y + 2f, 13f, 13f);
        if (e.type == EventType.Repaint)
        {
            EditorStyles.foldout.Draw(toggleRect, false, false, display, false);
        }

        if (e.type == EventType.MouseDown && rect.Contains(e.mousePosition))
        {
            display = !display;
            e.Use();
        }

        return display;
    }




    // --------------------------------
    //m_MaterialEditorのメソッドをUIとして使うもののみを指定する. 1行表示のテクスチャ＆カラー指定用.
    private static class Styles
    {
        public static GUIContent baseColorText = new GUIContent("BaseMap", "Base Color : Texture(sRGB) × Color(RGB) Default:White");
        public static GUIContent firstShadeColorText = new GUIContent("1st ShadeMap", "1st ShadeColor : Texture(sRGB) × Color(RGB) Default:White");
        public static GUIContent secondShadeColorText = new GUIContent("2nd ShadeMap", "2nd ShadeColor : Texture(sRGB) × Color(RGB) Default:White");
        public static GUIContent normalMapText = new GUIContent("NormalMap", "NormalMap : Texture(bump)");
        public static GUIContent highColorText = new GUIContent("HighColor", "High Color : Texture(sRGB) × Color(RGB) Default:Black");
        public static GUIContent highColorMaskText = new GUIContent("HighColor Mask", "HighColor Mask : Texture(linear)");
        public static GUIContent rimLightMaskText = new GUIContent("RimLight Mask", "RimLight Mask : Texture(linear)");
        public static GUIContent matCapSamplerText = new GUIContent("MatCap Sampler", "MatCap Sampler : Texture(sRGB) × Color(RGB) Default:White");
        public static GUIContent matCapMaskText = new GUIContent("MatCap Mask", "MatCap Mask : Texture(linear)");
        public static GUIContent angelRingText = new GUIContent("AngelRing", "AngelRing : Texture(sRGB) × Color(RGB) Default:Black");
        public static GUIContent emissiveTexText = new GUIContent("Emissive", "Emissive : Texture(sRGB)× EmissiveMask(alpha) × Color(HDR) Default:Black");
        public static GUIContent shadingGradeMapText = new GUIContent("Shading Grade Map", "影のかかり方マップ。UV座標で影のかかりやすい場所を指定する。Shading Grade Map : Texture(linear)");
        public static GUIContent firstPositionMapText = new GUIContent("1st Shade Position Map", "1影色領域に落ちる固定影の位置を、UV座標で指定する。1st Position Map : Texture(linear)");
        public static GUIContent secondPositionMapText = new GUIContent("2nd Shade Position Map", "2影色領域に落ちる固定影の位置を、UV座標で指定する。2nd Position Map : Texture(linear)");
        public static GUIContent outlineSamplerText = new GUIContent("Outline Sampler", "Outline Sampler : Texture(linear)");
        public static GUIContent outlineTexText = new GUIContent("Outline tex", "Outline Tex : Texture(sRGB) Default:White");
        public static GUIContent bakedNormalOutlineText = new GUIContent("Baked NormalMap for Outline", "Unpacked Normal Map : Texture(linear) ※通常のノーマルマップではないので注意");
        public static GUIContent clippingMaskText = new GUIContent("Clipping Mask", "Clipping Mask : Texture(linear)");
    }
    // --------------------------------

    public override void OnGUI(MaterialEditor materialEditor, MaterialProperty[] props)
    {
        EditorGUIUtility.fieldWidth = 0;
        FindProperties(props);
        m_MaterialEditor = materialEditor;
        Material material = materialEditor.target as Material;

        //v.2.0.7.2 / v.2.0.7.4
        //v.2.0.4.3p1以前のBaseMap名との互換性対策、および_utsVersionの更新をおこなう.
        //shader側で新規設定されるのは、_utsVersion = 2.07fなので、CustomGUI側でサブバージョンを付ける.
        if (material.GetFloat("_utsVersion") < _UTS2VersionNumber)
        {
            //_MainTexを使っている世代は、_BaseMapにはテクスチャ情報はない.
            if (material.GetTexture("_BaseMap") != null)
            {
                //v.2.0.4.3p1以前は_BaseMapにテクスチャ情報があるので、_MainTexにコピー.
                material.SetTexture("_MainTex", material.GetTexture("_BaseMap"));
                //処理が終わったので、_utsVersionを更新して設定.
                material.SetFloat("_utsVersion", _UTS2VersionNumber);
            }
            else
            {
                //処理が不要な場合も、_utsVersionを更新して設定.
                material.SetFloat("_utsVersion", _UTS2VersionNumber);
            }
        }
        //ここまで.

        //UTSのシェーダー方式の確認.
        CheckUtsTechnique(material);

        //1行目の横並び3ボタン.
        EditorGUILayout.BeginHorizontal();
        //Original Inspectorの選択チェック.
        if (material.HasProperty("_simpleUI"))
        {
            var selectedUI = material.GetInt("_simpleUI");
            if (selectedUI == 2)
            {
                _OriginalInspector = true;  //Original GUI
            }
            else if (selectedUI == 1)
            {
                _SimpleUI = true;   //UTS2 Biginner GUI
            }
            //Original/Custom GUI 切り替えボタン.
            if (_OriginalInspector)
            {
                if (GUILayout.Button("Change CustomUI", middleButtonStyle))
                {
                    _OriginalInspector = false;
                    material.SetInt("_simpleUI", 0); //UTS2 Pro GUI
                }
                OpenManualLink();
                //継承したレイアウトのクリア.
                EditorGUILayout.EndHorizontal();
                //オリジナルのGUI表示
                m_MaterialEditor.PropertiesDefaultGUI(props);
                return;
            }
            if (GUILayout.Button("Show All properties", middleButtonStyle))
            {
                _OriginalInspector = true;
                material.SetInt("_simpleUI", 2); //Original GUI
            }
        }
        //マニュアルを開く.
        OpenManualLink();
        EditorGUILayout.EndHorizontal();

        EditorGUI.BeginChangeCheck();

        EditorGUILayout.Space();

        _BasicShaderSettings_Foldout = Foldout(_BasicShaderSettings_Foldout, "Basic Shader Settings");
        if (_BasicShaderSettings_Foldout)
        {
            EditorGUI.indentLevel++;
            //EditorGUILayout.Space(); 
            GUI_SetCullingMode(material);

            if (material.HasProperty("_StencilNo"))
            {

                GUI_SetStencilNo(material);
            }

            if (material.HasProperty("_ClippingMask"))
            {
                GUI_SetClippingMask(material);
            }

            if (material.HasProperty("_Tweak_transparency"))
            {
                GUI_SetTransparencySetting(material);
            }

            GUI_OptionMenu(material);

            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        _BasicThreeColors_Foldout = Foldout(_BasicThreeColors_Foldout, "【Basic Three Colors and Control Maps Setups】");
        if (_BasicThreeColors_Foldout)
        {
            EditorGUI.indentLevel++;
            //EditorGUILayout.Space(); 
            GUI_BasicThreeColors(material);
            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        _StepAndFeather_Foldout = Foldout(_StepAndFeather_Foldout, "【Basic Lookdevs : Shading Step and Feather Settings】");
        if (_StepAndFeather_Foldout)
        {
            EditorGUI.indentLevel++;
            //EditorGUILayout.Space(); 
            GUI_StepAndFeather(material);
            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        _HighColor_Foldout = Foldout(_HighColor_Foldout, "【HighColor Settings】");
        if (_HighColor_Foldout)
        {
            EditorGUI.indentLevel++;
            EditorGUILayout.Space();
            GUI_HighColor(material);
            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        _RimLight_Foldout = Foldout(_RimLight_Foldout, "【RimLight Settings】");
        if (_RimLight_Foldout)
        {
            EditorGUI.indentLevel++;
            EditorGUILayout.Space();
            GUI_RimLight(material);
            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        _MatCap_Foldout = Foldout(_MatCap_Foldout, "【MatCap : Texture Projection Settings】");
        if (_MatCap_Foldout)
        {
            EditorGUI.indentLevel++;
            EditorGUILayout.Space();
            GUI_MatCap(material);
            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        if (material.HasProperty("_AngelRing"))
        {
            _AngelRing_Foldout = Foldout(_AngelRing_Foldout, "【AngelRing Projection Settings】");
            if (_AngelRing_Foldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.Space();
                GUI_AngelRing(material);
                EditorGUI.indentLevel--;
            }

            EditorGUILayout.Space();
        }

        _Emissive_Foldout = Foldout(_Emissive_Foldout, "【Emissive : Self-luminescence Settings】");
        if (_Emissive_Foldout)
        {
            EditorGUI.indentLevel++;
            //EditorGUILayout.Space();
            GUI_Emissive(material);
            EditorGUI.indentLevel--;
        }

        EditorGUILayout.Space();

        if (material.HasProperty("_OUTLINE"))
        {
            _Outline_Foldout = Foldout(_Outline_Foldout, "【Outline Settings】");
            if (_Outline_Foldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.Space();
                GUI_Outline(material);
                EditorGUI.indentLevel--;
            }
            EditorGUILayout.Space();
        }

        if (material.HasProperty("_TessEdgeLength"))
        {
            _Tessellation_Foldout = Foldout(_Tessellation_Foldout, "【DX11 Phong Tessellation Settings】");
            if (_Tessellation_Foldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.Space();
                GUI_Tessellation(material);
                EditorGUI.indentLevel--;
            }

            EditorGUILayout.Space();
        }

        if (!_SimpleUI)
        {
            _LightColorContribution_Foldout = Foldout(_LightColorContribution_Foldout, "【LightColor Contribution to Materials】");
            if (_LightColorContribution_Foldout)
            {
                EditorGUI.indentLevel++;
                //EditorGUILayout.Space();
                GUI_LightColorContribution(material);
                EditorGUI.indentLevel--;
            }

            EditorGUILayout.Space();

            _AdditionalLightingSettings_Foldout = Foldout(_AdditionalLightingSettings_Foldout, "【Environmental Lighting Contributions Setups】");
            if (_AdditionalLightingSettings_Foldout)
            {
                EditorGUI.indentLevel++;
                EditorGUILayout.Space();
                GUI_AdditionalLightingSettings(material);
                EditorGUI.indentLevel--;
            }

            EditorGUILayout.Space();
        }

        if (EditorGUI.EndChangeCheck())
        {
            m_MaterialEditor.PropertiesChanged();
        }

    }// End of OnGUI()


    // --------------------------------

    void CheckUtsTechnique(Material material)
    {
        if (material.HasProperty("_utsTechnique"))//DoubleWithFeather==0 or ShadingGradeMap==1
        {
            if (material.GetInt("_utsTechnique") == (int)_UTS_Technique.DoubleSideWithFeather)   //DWF
            {
                if (!material.HasProperty("_Set_1st_ShadePosition"))
                {
                    //SGMに変更.
                    material.SetInt("_utsTechnique", (int)_UTS_Technique.ShadingGradeMap);
                }
            }
            else if (material.GetInt("_utsTechnique") == (int)_UTS_Technique.ShadingGradeMap)
            {    //SGM
                 //SGM
                if (!material.HasProperty("_ShadingGradeMap"))
                {
                    //DWFに変更.
                    material.SetInt("_utsTechnique", (int)_UTS_Technique.DoubleSideWithFeather);
                }
            }
            else
            {

            }
        }
        else
        {

        }
    }

    void OpenManualLink()
    {
        if (GUILayout.Button("日本語マニュアル", middleButtonStyle))
        {
            Application.OpenURL("https://github.com/unity3d-jp/UnityChanToonShaderVer2_Project/blob/master/Manual/UTS2_Manual_ja.md");
        }
        if (GUILayout.Button("English manual", middleButtonStyle))
        {
            Application.OpenURL("https://github.com/unity3d-jp/UnityChanToonShaderVer2_Project/blob/master/Manual/UTS2_Manual_en.md");
        }
    }

    void GUI_SetCullingMode(Material material)
    {
        int _CullMode_Setting = material.GetInt("_CullMode");
        //Enum形式に変換して、outlineMode変数に保持しておく.
        if ((int)_CullingMode.CullingOff == _CullMode_Setting)
        {
            cullingMode = _CullingMode.CullingOff;
        }
        else if ((int)_CullingMode.FrontCulling == _CullMode_Setting)
        {
            cullingMode = _CullingMode.FrontCulling;
        }
        else
        {
            cullingMode = _CullingMode.BackCulling;
        }
        //EnumPopupでGUI記述.
        cullingMode = (_CullingMode)EditorGUILayout.EnumPopup("Culling Mode", cullingMode);
        //値が変化したらマテリアルに書き込み.
        if (cullingMode == _CullingMode.CullingOff)
        {
            material.SetFloat("_CullMode", 0);
        }
        else if (cullingMode == _CullingMode.FrontCulling)
        {
            material.SetFloat("_CullMode", 1);
        }
        else
        {
            material.SetFloat("_CullMode", 2);
        }
    }

    void GUI_SetStencilNo(Material material)
    {
        GUILayout.Label("For _StencilMask or _StencilOut Shader", EditorStyles.boldLabel);
        _StencilNo_Setting = material.GetInt("_StencilNo");
        int _Current_StencilNo = _StencilNo_Setting;
        _Current_StencilNo = (int)EditorGUILayout.IntField("Stencil No.", _Current_StencilNo);
        if (_StencilNo_Setting != _Current_StencilNo)
        {
            material.SetInt("_StencilNo", _Current_StencilNo);
        }
    }

    void GUI_SetClippingMask(Material material)
    {
        GUILayout.Label("For _Clipping or _TransClipping Shader", EditorStyles.boldLabel);
        m_MaterialEditor.TexturePropertySingleLine(Styles.clippingMaskText, clippingMask);

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Inverse Clipping Mask");
        //GUILayout.Space(60);
        if (material.GetFloat("_Inverse_Clipping") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Inverse_Clipping", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Inverse_Clipping", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        m_MaterialEditor.RangeProperty(clipping_Level, "Clipping Level");
    }

    void GUI_SetTransparencySetting(Material material)
    {

        GUILayout.Label("For _TransClipping Shader", EditorStyles.boldLabel);
        m_MaterialEditor.RangeProperty(tweak_transparency, "Transparency Level");

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Use BaseMap α as Clipping Mask");
        //GUILayout.Space(60);
        if (material.GetFloat("_IsBaseMapAlphaAsClippingMask") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_IsBaseMapAlphaAsClippingMask", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_IsBaseMapAlphaAsClippingMask", 0);
            }
        }
        EditorGUILayout.EndHorizontal();
    }

    void GUI_OptionMenu(Material material)
    {
        GUILayout.Label("Option Menu", EditorStyles.boldLabel);
        if (material.HasProperty("_simpleUI"))
        {
            if (material.GetInt("_simpleUI") == 1)
            {
                _SimpleUI = true; //UTS2 Custom GUI Biginner
            }
            else
            {
                _SimpleUI = false; //UTS2 Custom GUI Pro
            }
        }

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Current UI Type");
        //GUILayout.Space(60);
        if (_SimpleUI == false)
        {
            if (GUILayout.Button("Pro / Full Control", middleButtonStyle))
            {
                material.SetInt("_simpleUI", 1); //UTS2 Custom GUI Biginner
            }
        }
        else
        {
            if (GUILayout.Button("Biginner", middleButtonStyle))
            {
                material.SetInt("_simpleUI", 0); //UTS2 Custom GUI Pro
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("VRChat Recommendation");
        //GUILayout.Space(60);
        if (GUILayout.Button("Apply Settings", middleButtonStyle))
        {
            Set_Vrchat_Recommendation(material);
            _Use_VrcRecommend = true;
        }
        EditorGUILayout.EndHorizontal();
        if (_Use_VrcRecommend)
        {
            EditorGUILayout.HelpBox("UTS2 : Applied VRChat Recommended Settings.", MessageType.Info);
        }

        //v.2.0.7
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Remove Unused Keywords/Properties from Material");
        //GUILayout.Space(60);
        if (GUILayout.Button("Execute", middleButtonStyle))
        {
            RemoveUnusedKeywordsUtility(material);
            _RemovedUnusedKeywordsMessage = true;
        }
        EditorGUILayout.EndHorizontal();
        if (_RemovedUnusedKeywordsMessage)
        {
            EditorGUILayout.HelpBox("UTS2 : Unused Material Properties and ShaderKeywords are removed.", MessageType.Info);
        }
        //
    }

    //v.2.0.7
    void RemoveUnusedKeywordsUtility(Material material)
    {
        RemoveUnusedMaterialProperties(material);
        RemoveShaderKeywords(material);
    }

    void RemoveShaderKeywords(Material material)
    {
        string shaderKeywords = "";

        if (material.HasProperty("_EMISSIVE"))
        {
            float outlineMode = material.GetFloat("_EMISSIVE");
            if (outlineMode == 0)
            {
                shaderKeywords = shaderKeywords + "_EMISSIVE_SIMPLE";
            }
            else
            {
                shaderKeywords = shaderKeywords + "_EMISSIVE_ANIMATION";
            }
        }
        if (material.HasProperty("_OUTLINE"))
        {
            float outlineMode = material.GetFloat("_OUTLINE");
            if (outlineMode == 0)
            {
                shaderKeywords = shaderKeywords + " _OUTLINE_NML";
            }
            else
            {
                shaderKeywords = shaderKeywords + " _OUTLINE_POS";
            }
        }

        var so = new SerializedObject(material);
        so.Update();
        so.FindProperty("m_ShaderKeywords").stringValue = shaderKeywords;
        so.ApplyModifiedProperties();
    }

    // http://light11.hatenadiary.com/entry/2018/12/04/224253
    void RemoveUnusedMaterialProperties(Material material)
    {
        var sourceProps = new SerializedObject(material);
        sourceProps.Update();

        var savedProp = sourceProps.FindProperty("m_SavedProperties");

        // Tex Envs
        var texProp = savedProp.FindPropertyRelative("m_TexEnvs");
        for (int i = texProp.arraySize - 1; i >= 0; i--)
        {
            var propertyName = texProp.GetArrayElementAtIndex(i).FindPropertyRelative("first").stringValue;
            if (!material.HasProperty(propertyName))
            {
                texProp.DeleteArrayElementAtIndex(i);
            }
        }

        // Floats
        var floatProp = savedProp.FindPropertyRelative("m_Floats");
        for (int i = floatProp.arraySize - 1; i >= 0; i--)
        {
            var propertyName = floatProp.GetArrayElementAtIndex(i).FindPropertyRelative("first").stringValue;
            if (!material.HasProperty(propertyName))
            {
                floatProp.DeleteArrayElementAtIndex(i);
            }
        }

        // Colors
        var colorProp = savedProp.FindPropertyRelative("m_Colors");
        for (int i = colorProp.arraySize - 1; i >= 0; i--)
        {
            var propertyName = colorProp.GetArrayElementAtIndex(i).FindPropertyRelative("first").stringValue;
            if (!material.HasProperty(propertyName))
            {
                colorProp.DeleteArrayElementAtIndex(i);
            }
        }
        sourceProps.ApplyModifiedProperties();
    }
    //

    void Set_Vrchat_Recommendation(Material material)
    {
        material.SetFloat("_Is_LightColor_Base", 1);
        material.SetFloat("_Is_LightColor_1st_Shade", 1);
        material.SetFloat("_Is_LightColor_2nd_Shade", 1);
        material.SetFloat("_Is_LightColor_HighColor", 1);
        material.SetFloat("_Is_LightColor_RimLight", 1);
        material.SetFloat("_Is_LightColor_Ap_RimLight", 1);
        material.SetFloat("_Is_LightColor_MatCap", 1);
        if (material.HasProperty("_AngelRing"))
        {//AngelRingがある場合.
            material.SetFloat("_Is_LightColor_AR", 1);
        }
        if (material.HasProperty("_OUTLINE"))//OUTLINEがある場合.
        {
            material.SetFloat("_Is_LightColor_Outline", 1);
        }
        material.SetFloat("_Set_SystemShadowsToBase", 1);
        material.SetFloat("_Is_Filter_HiCutPointLightColor", 1);
        material.SetFloat("_CameraRolling_Stabilizer", 1);
        material.SetFloat("_Is_Ortho", 0);
        material.SetFloat("_GI_Intensity", 0);
        material.SetFloat("_Unlit_Intensity", 1);
        material.SetFloat("_Is_Filter_LightColor", 1);
    }

    void GUI_BasicThreeColors(Material material)
    {
        GUILayout.Label("3 Basic Colors Settings : Textures × Colors", EditorStyles.boldLabel);

        EditorGUILayout.BeginHorizontal();
        m_MaterialEditor.TexturePropertySingleLine(Styles.baseColorText, mainTex, baseColor);
        //v.2.0.7 Synchronize _Color to _BaseColor.
        if (material.HasProperty("_Color"))
        {
            material.SetColor("_Color", material.GetColor("_BaseColor"));
        }
        //
        if (material.GetFloat("_Use_BaseAs1st") == 0)
        {
            if (GUILayout.Button("No Sharing", middleButtonStyle))
            {
                material.SetFloat("_Use_BaseAs1st", 1);
            }
        }
        else
        {
            if (GUILayout.Button("With 1st ShadeMap", middleButtonStyle))
            {
                material.SetFloat("_Use_BaseAs1st", 0);
            }
        }
        GUILayout.Space(60);
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        m_MaterialEditor.TexturePropertySingleLine(Styles.firstShadeColorText, firstShadeMap, firstShadeColor);
        if (material.GetFloat("_Use_1stAs2nd") == 0)
        {
            if (GUILayout.Button("No Sharing", middleButtonStyle))
            {
                material.SetFloat("_Use_1stAs2nd", 1);
            }
        }
        else
        {
            if (GUILayout.Button("With 2nd ShadeMap", middleButtonStyle))
            {
                material.SetFloat("_Use_1stAs2nd", 0);
            }
        }
        GUILayout.Space(60);
        EditorGUILayout.EndHorizontal();

        m_MaterialEditor.TexturePropertySingleLine(Styles.secondShadeColorText, secondShadeMap, secondShadeColor);

        EditorGUILayout.Space();

        _NormalMap_Foldout = FoldoutSubMenu(_NormalMap_Foldout, "● NormalMap Settings");
        if (_NormalMap_Foldout)
        {
            //GUILayout.Label("NormalMap Settings", EditorStyles.boldLabel);
            m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMap, bumpScale);
            m_MaterialEditor.TextureScaleOffsetProperty(normalMap);

            //EditorGUI.indentLevel++;

            GUILayout.Label("NormalMap Effectiveness", EditorStyles.boldLabel);
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("3 Basic Colors");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_NormalMapToBase") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_NormalMapToBase", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_NormalMapToBase", 0);
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("HighColor");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_NormalMapToHighColor") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_NormalMapToHighColor", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_NormalMapToHighColor", 0);
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("RimLight");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_NormalMapToRimLight") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_NormalMapToRimLight", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_NormalMapToRimLight", 0);
                }
            }
            EditorGUILayout.EndHorizontal();

            //EditorGUI.indentLevel--;
            EditorGUILayout.Space();
        }

        _ShadowControlMaps_Foldout = FoldoutSubMenu(_ShadowControlMaps_Foldout, "● Shadow Control Maps");
        if (_ShadowControlMaps_Foldout)
        {
            GUI_ShadowControlMaps(material);
            EditorGUILayout.Space();
        }
    }

    void GUI_ShadowControlMaps(Material material)
    {
        if (material.HasProperty("_utsTechnique"))//DoubleWithFeather or ShadingGradeMap
        {
            if (material.GetInt("_utsTechnique") == (int)_UTS_Technique.DoubleSideWithFeather)   //DWF
            {
                GUILayout.Label("Technipue : Double Shade With Feather", EditorStyles.boldLabel);
                m_MaterialEditor.TexturePropertySingleLine(Styles.firstPositionMapText, set_1st_ShadePosition);
                m_MaterialEditor.TexturePropertySingleLine(Styles.secondPositionMapText, set_2nd_ShadePosition);
            }
            else if (material.GetInt("_utsTechnique") == (int)_UTS_Technique.ShadingGradeMap)
            {    //SGM
                GUILayout.Label("Technipue : Shading Grade Map", EditorStyles.boldLabel);
                m_MaterialEditor.TexturePropertySingleLine(Styles.shadingGradeMapText, shadingGradeMap);
                m_MaterialEditor.RangeProperty(tweak_ShadingGradeMapLevel, "ShadingGradeMap Level");
                m_MaterialEditor.RangeProperty(blurLevelSGM, "Blur Level of ShadingGradeMap");
            }
        }
    }

    void GUI_StepAndFeather(Material material)
    {
        GUI_BasicLookdevs(material);

        if (!_SimpleUI)
        {
            GUI_SystemShadows(material);

            if (material.HasProperty("_StepOffset"))//Mobile & Light Modeにはない項目.
            {
                //Line();
                //EditorGUILayout.Space();
                _AdditionalLookdevs_Foldout = FoldoutSubMenu(_AdditionalLookdevs_Foldout, "● Additional Settings");
                if (_AdditionalLookdevs_Foldout)
                {
                    GUI_AdditionalLookdevs(material);
                }
            }
        }
    }

    void GUI_SystemShadows(Material material)
    {

        GUILayout.Label("System Shadows : Self Shadows Receiving", EditorStyles.boldLabel);

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Receive System Shadows");
        //GUILayout.Space(60);
        if (material.GetFloat("_Set_SystemShadowsToBase") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Set_SystemShadowsToBase", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Set_SystemShadowsToBase", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        if (material.GetFloat("_Set_SystemShadowsToBase") == 1)
        {
            EditorGUI.indentLevel++;
            m_MaterialEditor.RangeProperty(tweak_SystemShadowsLevel, "System Shadows Level");
            EditorGUI.indentLevel--;
            EditorGUILayout.Space();
        }
        EditorGUILayout.Space();
    }

    void GUI_BasicLookdevs(Material material)
    {
        if (material.HasProperty("_utsTechnique"))//DoubleWithFeather or ShadingGradeMap
        {
            if (material.GetInt("_utsTechnique") == (int)_UTS_Technique.DoubleSideWithFeather)   //DWF
            {
                GUILayout.Label("Technipue : Double Shade With Feather", EditorStyles.boldLabel);
                m_MaterialEditor.RangeProperty(baseColor_Step, "BaseColor Step");
                m_MaterialEditor.RangeProperty(baseShade_Feather, "Base/Shade Feather");
                m_MaterialEditor.RangeProperty(shadeColor_Step, "ShadeColor Step");
                m_MaterialEditor.RangeProperty(first2nd_Shades_Feather, "1st/2nd_Shades Feather");
                //ShadingGradeMap系と変数を共有.
                material.SetFloat("_1st_ShadeColor_Step", material.GetFloat("_BaseColor_Step"));
                material.SetFloat("_1st_ShadeColor_Feather", material.GetFloat("_BaseShade_Feather"));
                material.SetFloat("_2nd_ShadeColor_Step", material.GetFloat("_ShadeColor_Step"));
                material.SetFloat("_2nd_ShadeColor_Feather", material.GetFloat("_1st2nd_Shades_Feather"));
            }
            else if (material.GetInt("_utsTechnique") == (int)_UTS_Technique.ShadingGradeMap)
            {    //SGM
                GUILayout.Label("Technipue : Shading Grade Map", EditorStyles.boldLabel);
                m_MaterialEditor.RangeProperty(first_ShadeColor_Step, "1st ShaderColor Step");
                m_MaterialEditor.RangeProperty(first_ShadeColor_Feather, "1st ShadeColor Feather");
                m_MaterialEditor.RangeProperty(second_ShadeColor_Step, "2nd ShadeColor Step");
                m_MaterialEditor.RangeProperty(second_ShadeColor_Feather, "2nd ShadeColor Feather");
                //DoubleWithFeather系と変数を共有.
                material.SetFloat("_BaseColor_Step", material.GetFloat("_1st_ShadeColor_Step"));
                material.SetFloat("_BaseShade_Feather", material.GetFloat("_1st_ShadeColor_Feather"));
                material.SetFloat("_ShadeColor_Step", material.GetFloat("_2nd_ShadeColor_Step"));
                material.SetFloat("_1st2nd_Shades_Feather", material.GetFloat("_2nd_ShadeColor_Feather"));
            }
            else
            {
                // OutlineObj.
                return;
            }
        }
        EditorGUILayout.Space();
    }

    void GUI_AdditionalLookdevs(Material material)
    {
        GUILayout.Label("    Settings for PointLights in ForwardAdd Pass");
        EditorGUI.indentLevel++;
        m_MaterialEditor.RangeProperty(stepOffset, "Step Offset for PointLights");

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("PointLights Hi-Cut Filter");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_Filter_HiCutPointLightColor") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_Filter_HiCutPointLightColor", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_Filter_HiCutPointLightColor", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUI.indentLevel--;
        EditorGUILayout.Space();
    }

    void GUI_HighColor(Material material)
    {
        m_MaterialEditor.TexturePropertySingleLine(Styles.highColorText, highColor_Tex, highColor);
        m_MaterialEditor.RangeProperty(highColor_Power, "HighColor Power");

        if (!_SimpleUI)
        {
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Specular Mode");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_SpecularToHighColor") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_SpecularToHighColor", 1);
                    material.SetFloat("_Is_BlendAddToHiColor", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_SpecularToHighColor", 0);
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Color Blend Mode");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_BlendAddToHiColor") == 0)
            {
                if (GUILayout.Button("Multiply", shortButtonStyle))
                {
                    material.SetFloat("_Is_BlendAddToHiColor", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Additive", shortButtonStyle))
                {
                    //加算モードはスペキュラオフでしか使えない.
                    if (material.GetFloat("_Is_SpecularToHighColor") == 1)
                    {
                        material.SetFloat("_Is_BlendAddToHiColor", 1);
                    }
                    else
                    {
                        material.SetFloat("_Is_BlendAddToHiColor", 0);
                    }
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("ShadowMask on HihgColor");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_UseTweakHighColorOnShadow") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_UseTweakHighColorOnShadow", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_UseTweakHighColorOnShadow", 0);
                }
            }
            EditorGUILayout.EndHorizontal();

            if (material.GetFloat("_Is_UseTweakHighColorOnShadow") == 1)
            {
                EditorGUI.indentLevel++;
                m_MaterialEditor.RangeProperty(tweakHighColorOnShadow, "HighColor Power on Shadow");
                EditorGUI.indentLevel--;
            }
        }

        EditorGUILayout.Space();
        //Line();
        //EditorGUILayout.Space();

        GUILayout.Label("    HighColor Mask", EditorStyles.boldLabel);
        EditorGUI.indentLevel++;
        m_MaterialEditor.TexturePropertySingleLine(Styles.highColorMaskText, set_HighColorMask);
        m_MaterialEditor.RangeProperty(tweak_HighColorMaskLevel, "HighColor Mask Level");
        EditorGUI.indentLevel--;

        EditorGUILayout.Space();
    }

    void GUI_RimLight(Material material)
    {
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("RimLight");
        //GUILayout.Space(60);
        if (material.GetFloat("_RimLight") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_RimLight", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_RimLight", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        if (material.GetFloat("_RimLight") == 1)
        {
            EditorGUI.indentLevel++;
            GUILayout.Label("    RimLight Settings", EditorStyles.boldLabel);
            m_MaterialEditor.ColorProperty(rimLightColor, "RimLight Color");
            m_MaterialEditor.RangeProperty(rimLight_Power, "RimLight Power");

            if (!_SimpleUI)
            {
                m_MaterialEditor.RangeProperty(rimLight_InsideMask, "RimLight Inside Mask");

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("RimLight FeatherOff");
                //GUILayout.Space(60);
                if (material.GetFloat("_RimLight_FeatherOff") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_RimLight_FeatherOff", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_RimLight_FeatherOff", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();
                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("LightDirection Mask");
                //GUILayout.Space(60);
                if (material.GetFloat("_LightDirection_MaskOn") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_LightDirection_MaskOn", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_LightDirection_MaskOn", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();

                if (material.GetFloat("_LightDirection_MaskOn") == 1)
                {
                    EditorGUI.indentLevel++;
                    m_MaterialEditor.RangeProperty(tweak_LightDirection_MaskLevel, "LightDirection MaskLevel");

                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PrefixLabel("Antipodean(Ap)_RimLight");
                    //GUILayout.Space(60);
                    if (material.GetFloat("_Add_Antipodean_RimLight") == 0)
                    {
                        if (GUILayout.Button("Off", shortButtonStyle))
                        {
                            material.SetFloat("_Add_Antipodean_RimLight", 1);
                        }
                    }
                    else
                    {
                        if (GUILayout.Button("Active", shortButtonStyle))
                        {
                            material.SetFloat("_Add_Antipodean_RimLight", 0);
                        }
                    }
                    EditorGUILayout.EndHorizontal();

                    if (material.GetFloat("_Add_Antipodean_RimLight") == 1)
                    {
                        EditorGUI.indentLevel++;
                        GUILayout.Label("    Ap_RimLight Settings", EditorStyles.boldLabel);
                        m_MaterialEditor.ColorProperty(ap_RimLightColor, "Ap_RimLight Color");
                        m_MaterialEditor.RangeProperty(ap_RimLight_Power, "Ap_RimLight Power");

                        EditorGUILayout.BeginHorizontal();
                        EditorGUILayout.PrefixLabel("Ap_RimLight FeatherOff");
                        //GUILayout.Space(60);
                        if (material.GetFloat("_Ap_RimLight_FeatherOff") == 0)
                        {
                            if (GUILayout.Button("Off", shortButtonStyle))
                            {
                                material.SetFloat("_Ap_RimLight_FeatherOff", 1);
                            }
                        }
                        else
                        {
                            if (GUILayout.Button("Active", shortButtonStyle))
                            {
                                material.SetFloat("_Ap_RimLight_FeatherOff", 0);
                            }
                        }
                        EditorGUILayout.EndHorizontal();
                        EditorGUI.indentLevel--;
                    }

                    EditorGUI.indentLevel--;

                }//Light Direction Mask ON

            }

            //EditorGUI.indentLevel++;

            EditorGUILayout.Space();
            //Line();
            //EditorGUILayout.Space();

            GUILayout.Label("    RimLight Mask", EditorStyles.boldLabel);
            m_MaterialEditor.TexturePropertySingleLine(Styles.rimLightMaskText, set_RimLightMask);
            m_MaterialEditor.RangeProperty(tweak_RimLightMaskLevel, "RimLight Mask Level");

            //EditorGUI.indentLevel--;

            EditorGUI.indentLevel--;
            EditorGUILayout.Space();
        }
    }

    void GUI_MatCap(Material material)
    {
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("MatCap");
        //GUILayout.Space(60);
        if (material.GetFloat("_MatCap") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_MatCap", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_MatCap", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        if (material.GetFloat("_MatCap") == 1)
        {
            GUILayout.Label("    MatCap Settings", EditorStyles.boldLabel);
            m_MaterialEditor.TexturePropertySingleLine(Styles.matCapSamplerText, matCap_Sampler, matCapColor);
            EditorGUI.indentLevel++;
            m_MaterialEditor.TextureScaleOffsetProperty(matCap_Sampler);

            if (!_SimpleUI)
            {

                m_MaterialEditor.RangeProperty(blurLevelMatcap, "Blur Level of MatCap Sampler");

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("Color Blend Mode");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_BlendAddToMatCap") == 0)
                {
                    if (GUILayout.Button("Multipy", shortButtonStyle))
                    {
                        material.SetFloat("_Is_BlendAddToMatCap", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Additive", shortButtonStyle))
                    {
                        material.SetFloat("_Is_BlendAddToMatCap", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();

                m_MaterialEditor.RangeProperty(tweak_MatCapUV, "Scale MatCapUV");
                m_MaterialEditor.RangeProperty(rotate_MatCapUV, "Rotate MatCapUV");

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("CameraRolling Stabilizer");
                //GUILayout.Space(60);
                if (material.GetFloat("_CameraRolling_Stabilizer") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_CameraRolling_Stabilizer", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_CameraRolling_Stabilizer", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("NormalMap for MatCap");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_NormalMapForMatCap") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_Is_NormalMapForMatCap", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_Is_NormalMapForMatCap", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();
                if (material.GetFloat("_Is_NormalMapForMatCap") == 1)
                {
                    EditorGUI.indentLevel++;
                    GUILayout.Label("       NormalMap for MatCap as SpecularMask", EditorStyles.boldLabel);
                    m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, normalMapForMatCap, bumpScaleMatcap);
                    m_MaterialEditor.TextureScaleOffsetProperty(normalMapForMatCap);
                    m_MaterialEditor.RangeProperty(rotate_NormalMapForMatCapUV, "Rotate NormalMapUV");
                    EditorGUI.indentLevel--;
                }

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("MatCap on Shadow");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_UseTweakMatCapOnShadow") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_Is_UseTweakMatCapOnShadow", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_Is_UseTweakMatCapOnShadow", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();
                if (material.GetFloat("_Is_UseTweakMatCapOnShadow") == 1)
                {
                    EditorGUI.indentLevel++;
                    m_MaterialEditor.RangeProperty(tweakMatCapOnShadow, "MatCap Power on Shadow");
                    EditorGUI.indentLevel--;
                }

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("MatCap Projection Camera");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_Ortho") == 0)
                {
                    if (GUILayout.Button("Perspective", middleButtonStyle))
                    {
                        material.SetFloat("_Is_Ortho", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Orthographic", middleButtonStyle))
                    {
                        material.SetFloat("_Is_Ortho", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();
            }

            EditorGUILayout.Space();
            //Line();
            //EditorGUILayout.Space();

            GUILayout.Label("    MatCap Mask", EditorStyles.boldLabel);
            m_MaterialEditor.TexturePropertySingleLine(Styles.matCapMaskText, set_MatcapMask);
            m_MaterialEditor.TextureScaleOffsetProperty(set_MatcapMask);
            m_MaterialEditor.RangeProperty(tweak_MatcapMaskLevel, "MatCap Mask Level");

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Inverse Matcap Mask");
            //GUILayout.Space(60);
            if (material.GetFloat("_Inverse_MatcapMask") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Inverse_MatcapMask", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Inverse_MatcapMask", 0);
                }
            }
            EditorGUILayout.EndHorizontal();

            EditorGUI.indentLevel--;
        } // MatCap == 1

        //EditorGUILayout.Space();
    }

    void GUI_AngelRing(Material material)
    {
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("AngelRing Projection");
        //GUILayout.Space(60);
        if (material.GetFloat("_AngelRing") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_AngelRing", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_AngelRing", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        if (material.GetFloat("_AngelRing") == 1)
        {
            GUILayout.Label("    AngelRing Sampler Settings", EditorStyles.boldLabel);
            m_MaterialEditor.TexturePropertySingleLine(Styles.angelRingText, angelRing_Sampler, angelRing_Color);
            EditorGUI.indentLevel++;
            //m_MaterialEditor.TextureScaleOffsetProperty(angelRing_Sampler);
            m_MaterialEditor.RangeProperty(ar_OffsetU, "Offset U");
            m_MaterialEditor.RangeProperty(ar_OffsetV, "Offset V");

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Use α channel as Clipping Mask");
            //GUILayout.Space(60);
            if (material.GetFloat("_ARSampler_AlphaOn") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_ARSampler_AlphaOn", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_ARSampler_AlphaOn", 0);
                }
            }
            EditorGUILayout.EndHorizontal();
            EditorGUI.indentLevel--;

        }
    }

    void GUI_Emissive(Material material)
    {
        GUILayout.Label("Emissive Tex × HDR Color", EditorStyles.boldLabel);
        GUILayout.Label("(Bloom Post-Processing Effect necessary)");
        EditorGUILayout.Space();
        m_MaterialEditor.TexturePropertySingleLine(Styles.emissiveTexText, emissive_Tex, emissive_Color);
        m_MaterialEditor.TextureScaleOffsetProperty(emissive_Tex);

        int _EmissiveMode_Setting = material.GetInt("_EMISSIVE");
        if ((int)_EmissiveMode.SimpleEmissive == _EmissiveMode_Setting)
        {
            emissiveMode = _EmissiveMode.SimpleEmissive;
        }
        else if ((int)_EmissiveMode.EmissiveAnimation == _EmissiveMode_Setting)
        {
            emissiveMode = _EmissiveMode.EmissiveAnimation;
        }
        EditorGUILayout.Space();
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Emissive Animation");
        //GUILayout.Space(60);
        if (emissiveMode == _EmissiveMode.SimpleEmissive)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_EMISSIVE", 1);
                material.EnableKeyword("_EMISSIVE_ANIMATION");
                material.DisableKeyword("_EMISSIVE_SIMPLE");
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_EMISSIVE", 0);
                material.EnableKeyword("_EMISSIVE_SIMPLE");
                material.DisableKeyword("_EMISSIVE_ANIMATION");
            }
        }
        EditorGUILayout.EndHorizontal();

        if (emissiveMode == _EmissiveMode.EmissiveAnimation)
        {
            EditorGUI.indentLevel++;

            EditorGUILayout.BeginHorizontal();
            m_MaterialEditor.FloatProperty(base_Speed, "Base Speed (Time)");
            //EditorGUILayout.PrefixLabel("Select Scroll Coord");
            //GUILayout.Space(60);
            if (!_SimpleUI)
            {
                if (material.GetFloat("_Is_ViewCoord_Scroll") == 0)
                {
                    if (GUILayout.Button("UV Coord Scroll", shortButtonStyle))
                    {
                        material.SetFloat("_Is_ViewCoord_Scroll", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("View Coord Scroll", shortButtonStyle))
                    {
                        material.SetFloat("_Is_ViewCoord_Scroll", 0);
                    }
                }
            }
            EditorGUILayout.EndHorizontal();

            m_MaterialEditor.RangeProperty(scroll_EmissiveU, "Scroll U/X direction");
            m_MaterialEditor.RangeProperty(scroll_EmissiveV, "Scroll V/Y direction");
            m_MaterialEditor.FloatProperty(rotate_EmissiveUV, "Rotate around UV center");

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("PingPong Move for Base");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_PingPong_Base") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_PingPong_Base", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_PingPong_Base", 0);
                }
            }
            EditorGUILayout.EndHorizontal();
            EditorGUI.indentLevel--;

            if (!_SimpleUI)
            {
                EditorGUILayout.Space();

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("ColorShift with Time");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_ColorShift") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_Is_ColorShift", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_Is_ColorShift", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();
                EditorGUI.indentLevel++;
                if (material.GetFloat("_Is_ColorShift") == 1)
                {
                    m_MaterialEditor.ColorProperty(colorShift, "Destination Color");
                    m_MaterialEditor.FloatProperty(colorShift_Speed, "ColorShift Speed (Time)");
                }
                EditorGUI.indentLevel--;

                EditorGUILayout.Space();

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("ViewShift of Color");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_ViewShift") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_Is_ViewShift", 1);
                    }
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_Is_ViewShift", 0);
                    }
                }
                EditorGUILayout.EndHorizontal();
                EditorGUI.indentLevel++;
                if (material.GetFloat("_Is_ViewShift") == 1)
                {
                    m_MaterialEditor.ColorProperty(viewShift, "ViewShift Color");
                }
                EditorGUI.indentLevel--;
            }//!_SimpleUI
        }
        EditorGUILayout.Space();
    }


    void GUI_Outline(Material material)
    {
        //Shaderプロパティ [KeywordEnum(NML,POS)] をEumPopupで表現する.
        //マテリアル内のアウトラインモードの設定を読み込み.
        int _OutlineMode_Setting = material.GetInt("_OUTLINE");
        //Enum形式に変換して、outlineMode変数に保持しておく.
        if ((int)_OutlineMode.NormalDirection == _OutlineMode_Setting)
        {
            outlineMode = _OutlineMode.NormalDirection;
        }
        else if ((int)_OutlineMode.PositionScaling == _OutlineMode_Setting)
        {
            outlineMode = _OutlineMode.PositionScaling;
        }
        //EnumPopupでGUI記述.
        outlineMode = (_OutlineMode)EditorGUILayout.EnumPopup("Outline Mode", outlineMode);
        //値が変化したらマテリアルに書き込み.
        if (outlineMode == _OutlineMode.NormalDirection)
        {
            material.SetFloat("_OUTLINE", 0);
            //UTCS_Outline.cginc側のキーワードもトグル入れ替え.
            material.EnableKeyword("_OUTLINE_NML");
            material.DisableKeyword("_OUTLINE_POS");
        }
        else if (outlineMode == _OutlineMode.PositionScaling)
        {
            material.SetFloat("_OUTLINE", 1);
            material.EnableKeyword("_OUTLINE_POS");
            material.DisableKeyword("_OUTLINE_NML");
        }

        m_MaterialEditor.FloatProperty(outline_Width, "Outline Width");
        m_MaterialEditor.ColorProperty(outline_Color, "Outline Color");

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Blend BaseColor to Outline");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_BlendBaseColor") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_BlendBaseColor", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_BlendBaseColor", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        m_MaterialEditor.TexturePropertySingleLine(Styles.outlineSamplerText, outline_Sampler);
        m_MaterialEditor.FloatProperty(offset_Z, "Offset Outline with Camera Z-axis");

        if (!_SimpleUI)
        {

            _AdvancedOutline_Foldout = FoldoutSubMenu(_AdvancedOutline_Foldout, "● Advanced Outline Settings");
            if (_AdvancedOutline_Foldout)
            {
                EditorGUI.indentLevel++;
                GUILayout.Label("    Camera Distance for Outline Width");
                m_MaterialEditor.FloatProperty(farthest_Distance, "● Farthest Distance to vanish");
                m_MaterialEditor.FloatProperty(nearest_Distance, "● Nearest Distance to draw with Outline Width");
                EditorGUI.indentLevel--;

                EditorGUILayout.BeginHorizontal();
                EditorGUILayout.PrefixLabel("Use Outline Texture");
                //GUILayout.Space(60);
                if (material.GetFloat("_Is_OutlineTex") == 0)
                {
                    if (GUILayout.Button("Off", shortButtonStyle))
                    {
                        material.SetFloat("_Is_OutlineTex", 1);
                    }
                    EditorGUILayout.EndHorizontal();
                }
                else
                {
                    if (GUILayout.Button("Active", shortButtonStyle))
                    {
                        material.SetFloat("_Is_OutlineTex", 0);
                    }
                    EditorGUILayout.EndHorizontal();
                    m_MaterialEditor.TexturePropertySingleLine(Styles.outlineTexText, outlineTex);
                }

                if (outlineMode == _OutlineMode.NormalDirection)
                {
                    EditorGUILayout.BeginHorizontal();
                    EditorGUILayout.PrefixLabel("Use Baked Normal for Outline");
                    //GUILayout.Space(60);
                    if (material.GetFloat("_Is_BakedNormal") == 0)
                    {
                        if (GUILayout.Button("Off", shortButtonStyle))
                        {
                            material.SetFloat("_Is_BakedNormal", 1);
                        }
                        EditorGUILayout.EndHorizontal();
                    }
                    else
                    {
                        if (GUILayout.Button("Active", shortButtonStyle))
                        {
                            material.SetFloat("_Is_BakedNormal", 0);
                        }
                        EditorGUILayout.EndHorizontal();
                        m_MaterialEditor.TexturePropertySingleLine(Styles.bakedNormalOutlineText, bakedNormal);
                    }
                }
            }
        }
    }

    void GUI_Tessellation(Material material)
    {
        GUILayout.Label("Technique : DX11 Phong Tessellation", EditorStyles.boldLabel);
        m_MaterialEditor.RangeProperty(tessEdgeLength, "Edge Length");
        m_MaterialEditor.RangeProperty(tessPhongStrength, "Phong Strength");
        m_MaterialEditor.RangeProperty(tessExtrusionAmount, "Extrusion Amount");

        EditorGUILayout.Space();
    }

    void GUI_LightColorContribution(Material material)
    {
        GUILayout.Label("Realtime LightColor Contribution to each colors", EditorStyles.boldLabel);
        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Base Color");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_Base") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_Base", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_Base", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("1st ShadeColor");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_1st_Shade") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_1st_Shade", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_1st_Shade", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("2nd ShadeColor");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_2nd_Shade") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_2nd_Shade", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_2nd_Shade", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("HighColor");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_HighColor") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_HighColor", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_HighColor", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("RimLight");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_RimLight") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_RimLight", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_RimLight", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Ap_RimLight");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_Ap_RimLight") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_Ap_RimLight", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_Ap_RimLight", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("MatCap");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_LightColor_MatCap") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_MatCap", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_LightColor_MatCap", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        if (material.HasProperty("_AngelRing"))//AngelRingがある場合.
        {
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Angel Ring");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_LightColor_AR") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_LightColor_AR", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_LightColor_AR", 0);
                }
            }
            EditorGUILayout.EndHorizontal();
        }

        if (material.HasProperty("_OUTLINE"))//OUTLINEがある場合.
        {
            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("Outline");
            //GUILayout.Space(60);
            if (material.GetFloat("_Is_LightColor_Outline") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Is_LightColor_Outline", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Is_LightColor_Outline", 0);
                }
            }
            EditorGUILayout.EndHorizontal();
        }
        EditorGUILayout.Space();
    }

    void GUI_AdditionalLightingSettings(Material material)
    {
        m_MaterialEditor.RangeProperty(gi_Intensity, "GI Intensity");
        m_MaterialEditor.RangeProperty(unlit_Intensity, "Unlit Intensity");

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("SceneLights Hi-Cut Filter");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_Filter_LightColor") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_Filter_LightColor", 1);
                material.SetFloat("_Is_LightColor_Base", 1);
                material.SetFloat("_Is_LightColor_1st_Shade", 1);
                material.SetFloat("_Is_LightColor_2nd_Shade", 1);
                if (material.HasProperty("_OUTLINE"))//OUTLINEがある場合.
                {
                    material.SetFloat("_Is_LightColor_Outline", 1);
                }
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_Filter_LightColor", 0);
            }
        }
        EditorGUILayout.EndHorizontal();

        EditorGUILayout.BeginHorizontal();
        EditorGUILayout.PrefixLabel("Built-in Light Direction");
        //GUILayout.Space(60);
        if (material.GetFloat("_Is_BLD") == 0)
        {
            if (GUILayout.Button("Off", shortButtonStyle))
            {
                material.SetFloat("_Is_BLD", 1);
            }
        }
        else
        {
            if (GUILayout.Button("Active", shortButtonStyle))
            {
                material.SetFloat("_Is_BLD", 0);
            }
        }
        EditorGUILayout.EndHorizontal();
        if (material.GetFloat("_Is_BLD") == 1)
        {
            GUILayout.Label("    Built-in Light Direction Settings");
            EditorGUI.indentLevel++;
            m_MaterialEditor.RangeProperty(offset_X_Axis_BLD, "● Offset X-Axis Direction");
            m_MaterialEditor.RangeProperty(offset_Y_Axis_BLD, "● Offset Y-Axis Direction");

            EditorGUILayout.BeginHorizontal();
            EditorGUILayout.PrefixLabel("● Inverse Z-Axis Direction");
            //GUILayout.Space(60);
            if (material.GetFloat("_Inverse_Z_Axis_BLD") == 0)
            {
                if (GUILayout.Button("Off", shortButtonStyle))
                {
                    material.SetFloat("_Inverse_Z_Axis_BLD", 1);
                }
            }
            else
            {
                if (GUILayout.Button("Active", shortButtonStyle))
                {
                    material.SetFloat("_Inverse_Z_Axis_BLD", 0);
                }
            }
            EditorGUILayout.EndHorizontal();
            EditorGUI.indentLevel--;
        }
        EditorGUILayout.Space();
    }

} // End of UTS2GUI2